"""
age = int(input("请输入你的年龄"))
if age >=0 and age<3:
    for i in range(3):
        print("小兔子乖乖")
        print("把门儿开开")
        print("快点儿开开")
        print("我要进来")
elif 5 > age >=3:
    print("小兔子乖乖")
    print("把门儿开开")
    print("快点开开")
    print("我要进来")
"""
# 以上代码  有缺点
# 缺点：代码冗余，可读性很差，维护性太差

# 封装函数
def text():
    print("小兔子乖乖")
    print("把门儿开开")
    print("快点开开！")
    print("我要金来！")
# 函数只有在调用才会被执行，不然没有效果展示
# 调用函数
# text()
"""
age = int(input("请输入你的年龄"))
if age >=0 and age<3:
    for i in range(3):
        text()
elif 5>age>=3:
    text()
"""

# =====================第一种函数体现： 无形参，无返回===============================
def student():
    print("我们是沁创第四期")
    print("正在学习")
# 调用函数
# student()
# print(student())        # None 就说明这个函数是无返回值的

# =====================第二种函数体现： 无形参，有返回===============================
def student1():
    print("我们是沁创第四期")
    return "正在学习"       # 函数执行到此，会停止并返回，是函数的返回值
"""
一个函数里面，只能有一个return
return后面的代码块不会被执行
"""
def student2():
    print("我们是沁创第四期")
    return "正在学习"       # 函数执行到此，会停止并返回，是函数的返回值
    print("就是截至了")
    return "刘超正在学习ing"
# student2()
# print(student2())

# s = "刘超" + student2()       # 刘超正在学习
# print(s)
# print(student2())
def student3():
    r = input("请选择要查询的班级：")
    if r == '1':
        return "已就业"
    elif r == '2':
        return "上班"
    elif r=='3':
        return '等待上班'
    elif r=='4':
        return '学习'
# print(student3())

# =====================第三种函数体现： 有形参，无返回===============================
# 第一个案例
def student4(stu:str):
    """
    :param stu: 形参，形式参数；str提醒程序员，传参类型是要字符串格式的
    :return:
    """
    if stu == "刘超":
        print("班长在！")
    elif stu == '丁涵':
        print("我是丁涵")
# 调用函数
# student4("刘超")      # "刘超"就是实参， 实际参数
"""
简单理解一下，就是stu形参，刘超是实参，把刘超赋值给了stu，那么stu就是刘超！
"""

# 第二个案例
def studentInfo(name:str,age:int,address,sex):
    """
    :param name: 姓名，提醒程序员传参是字符串
    :param age: 年龄，提醒程序员传参是整数
    :param address: 地址
    :param sex: 性别
    :return:
    """
    print(f"大家好，我叫做：{name}，今年：{age}岁，来自：{address}，性别为：{sex}")

# 调用函数
"""
name = 刘超
age = 19
address = 辽宁沈阳沈北新区浦和路
sex = 女
"""
# studentInfo("刘超",19,"辽宁沈阳沈北新区浦和路","女")

# 改变传参顺序，调用
# studentInfo(age=10,name='刘超',address='吉林吉林',sex='男')

# 第三个案例：默认参数必须放到最后面
def stuInfo(name,age,sex='男'):
    """
    :param name: 姓名
    :param age: 年龄
    :param sex: 性别，默认为男
    :return:
    """
    print(f"大家好，我叫：{name}，今年：{age}岁，性别为：{sex}")
# 调用函数
# stuInfo("刘超",100)

# 第四个案例：不定长参数，正常的参数前面加一个*就可以
def stuInfo2(*args):
    """
    :param args: 接受无限制的参数，任意类型都可以，返回的是一个元组
    :return:
    """
    print(f"不定长参数张这个样子：{args}")
    print(f"大家好，我叫做：{args[0]}，今年：{args[1]}岁，来自：{args[2]}")
#调用函数
# stuInfo2("刘超",'19','辽宁沈阳')

# 第五个案例：不定长参数，默认值参数，正常参数都存在
def stuInfo3(name,age,sex='男',*args):
    print(name)
    print(age)
    print(sex)
    print(args)
# 调用函数
# stuInfo3("刘超",19,'女',[1,2,3],(1,2,3),{"姓名":"刘超"},'lisi','tiki',1,{1,2,3})
"""
刘超
19
女
([1,2,3],(1,2,3),{"姓名":"刘超"},'lisi','tiki',1,{1,2,3})
"""
# 第六个案例：不定长关键字参数，接收的是一个键值对，返回的是字典
def stuInfo4(**kwargs):
    print(kwargs)
# 调用函数
# stuInfo4(name='张三',地址='辽宁沈阳',age=19,性别='女')
# {"name":"张三","地址":"辽宁沈阳","age":19,"性别":"女"}


# 第七个案例：不定长参数，不定长关键字参数，默认值参数，普通形参
def stuInfo5(name,age,sex='男',*args,**kwargs):
    print(name)
    print(age)
    print(sex)
    print(args)
    print(kwargs)
# 调用函数
# stuInfo5([11,2,33,44],{5,5,5,666},"张三","aa",[5,5,5],(1,1,1),{"name":"李四"},{"张三":"李四"},nn='qqq')
"""
[11,2,33,44]
{5,666}
张三
(aa [5,5,5] (1,1,1) {"name":"李四"},{"张三":"李四"})
{"nn":"qqq"}
"""
# =====================第四种函数体现： 有形参，有返回===============================
def student5(name,age,sex):
    return f"大家好，我叫做：{name}，今年：{age}岁，性别为：{sex}"
# print(student5("刘超", 100, '女'))

#===================全局变量和局部变量=========================
# 第一个案例：有全局变量和局部变量重名de
age = 5     # 全局变量
def stu():
    age = 15        # 局部变量，仅供stu函数来使用
    print(f"大家好，我今年：{age}岁")
# 调用函数
# print(age)
# stu()
# print(age)
"""
5
大家好，我今年15岁
5
"""
# 第二个案例：有全局变量，但是局部变量没有这个定义
name = "张三"
def stu1():
    print(f"大家好，我的名字是：{name}")
# 调用函数
# stu1()
"""
当函数里面没有这个变量时，全局有，那么会用全局的变量来使用
"""
# 第三个案例：我想修改全局的变量
address = "沈阳"
def stu2():
    global address      # global引用全局的变量，在后面进行修改，会影响到全局
    address = "辽宁大连"
    print(f"家庭地址发生变更：{address}")
# 调用函数
"""
print(address)
stu2()
print(address)
"""

#===================在一个函数里调用另外一个函数：解耦=========================
def start():
    print("正在启动...")
def play():
    start()
    print("玩游戏")
def kill_server():
    play()
    print("结束游戏~")

# 是不是可以理解为，只需要调用kill_server，其他两个函数都调用了
# kill_server()

# start()
# play()
# kill_server()

"""
总结：
1、函数的封装
2、函数形参：不定长参数(*args)、不定长关键字参数(**kwargs)、默认值参数、普通参数
3、函数的几种形态：有形参有返回，无形参无返回，有形参无返回，无形参有返回
4、全局变量与局部变量
5、在函数体里面修改全局变量
6、在一个函数体里面调用另外一个函数
"""







